home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 2 / AACD 2.iso / AACD / Magazine / GraphicsCards / StormMesa / demos / stex3d.c < prev    next >
C/C++ Source or Header  |  1998-12-15  |  15KB  |  576 lines
  1. /* $Id: stex3d.c,v 3.1 1998/06/09 01:53:49 brianp Exp $ */
  2.  
  3. /*----------------------------- 
  4.  * stex3d.c GL example of the mesa 3d-texture extention to simulate procedural
  5.  *            texturing, it uses a perlin noise and turbulence functions.
  6.  * 
  7.  * Author:   Daniel Barrero
  8.  *           barrero@irit.fr
  9.  *           dbarrero@pegasus.uniandes.edu.co
  10.  *
  11.  * Converted to GLUT by brianp on 1/1/98
  12.  *
  13.  *      
  14.  * cc stex3d.c -o stex3d -lglut -lMesaGLU -lMesaGL -lX11 -lXext -lm 
  15.  *
  16.  *---------------------------- */
  17.  
  18. /*
  19.  * $Log: stex3d.c,v $
  20.  * Revision 3.1  1998/06/09 01:53:49  brianp
  21.  * main() should return an int
  22.  *
  23.  * Revision 3.0  1998/02/14 18:42:29  brianp
  24.  * initial rev
  25.  *
  26.  */
  27.  
  28.  
  29. #include <string.h>
  30. #include <stdio.h>
  31. #include <stdlib.h>
  32. #include <math.h>
  33. #include <GL/gl.h>
  34. #include <GL/glut.h>
  35. /* function declarations */
  36. #ifndef M_PI
  37. #define M_PI            3.14159265358979323846
  38. #endif
  39.  
  40. void init(void),
  41.      printHelp(void),
  42.      create3Dtexture(void),
  43.      setDefaults(void),
  44.      drawScene(void),
  45.      resize(int w, int h),
  46.      buildFigure(void),
  47.      initNoise(void);
  48. float turbulence(float point[3], float lofreq, float hifreq);
  49.  
  50. int isExtSupported(char *ext);
  51. void KeyHandler( unsigned char key, int x, int y );
  52. GLenum parseCmdLine(int argc, char **argv);
  53. float noise3(float vec[3]);
  54.       
  55. /* global variables */
  56. GLenum rgb, doubleBuffer, directRender, windType; /* visualization state*/
  57. float tex_width,tex_height,tex_depth;        /* texture volume dimensions  */
  58. unsigned char *voxels;                       /* texture data ptr */
  59. int angx,angy,angz;
  60. GLuint figure;
  61.  
  62. /*function definitions */
  63. int main(int argc, char **argv)
  64. {
  65.  
  66.  if (parseCmdLine(argc, argv) == GL_FALSE) {
  67.     exit(0);
  68.  }
  69.  
  70.  glutInitWindowPosition(0, 0);
  71.  glutInitWindowSize(400, 400);
  72.  windType = (rgb) ? GLUT_RGB : GLUT_INDEX;
  73.  windType |= (doubleBuffer) ? GLUT_DOUBLE : GLUT_SINGLE;
  74.  windType |= GLUT_DEPTH;
  75.  glutInitDisplayMode(windType);
  76.  
  77.  if (glutCreateWindow("stex3d") <= 0) {
  78.     exit(0);
  79.  }
  80.  /* init all */
  81.  init();
  82.  
  83.  glutReshapeFunc(resize);
  84.  glutKeyboardFunc(KeyHandler);
  85.  glutDisplayFunc(drawScene);
  86.  glutMainLoop();
  87.  return 0;
  88. }
  89.  
  90. void init()
  91. { 
  92.  /* init light */
  93.  GLfloat mat_specular[] = { 1.0, 1.0, 1.0, 1.0 };
  94.  GLfloat mat_shininess[] = { 25.0 };
  95.  GLfloat gray[] = { 0.6, 0.6, 0.6, 0.0 };
  96.  GLfloat white[] = { 1.0, 1.0, 1.0, 0.0 };
  97.  GLfloat light_position[] = { 0.0, 1.0, 1.0, 0.0 };
  98.  
  99.  glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);
  100.  glMaterialfv(GL_FRONT, GL_SHININESS, mat_shininess);
  101.  glLightfv(GL_LIGHT1, GL_POSITION, light_position);
  102.  glLightfv(GL_LIGHT1, GL_AMBIENT, gray);
  103.  glLightfv(GL_LIGHT1, GL_DIFFUSE, white);
  104.  glLightfv(GL_LIGHT1, GL_SPECULAR, white);
  105.  glColorMaterial(GL_FRONT, GL_DIFFUSE);
  106.  glEnable(GL_COLOR_MATERIAL);
  107.  glEnable(GL_LIGHTING);
  108.  glEnable(GL_LIGHT1);
  109.  
  110.  /* create torus for texturing */
  111.  figure=glGenLists(1); 
  112.  buildFigure();
  113. /* tkSolidTorus(figure,0.3,1.2);*/
  114.  
  115.  /* start the noise function variables */
  116.  initNoise();
  117.  
  118.  /* see if the texture 3d extention is supported */
  119.  if (!isExtSupported("GL_EXT_texture3D")) {
  120.    printf("Sorry this GL implementation (%s) does not support 3d texture extentions\n",
  121.     (char *)(glGetString(GL_RENDERER)));
  122. /*   tkQuit();*/
  123.  }
  124.  
  125.  /* if texture is supported then generate the texture */
  126.  create3Dtexture(); 
  127.  
  128.  glEnable(GL_TEXTURE_3D_EXT); 
  129.  /*
  130.  glBlendFunc(GL_SRC_COLOR, GL_SRC_ALPHA);
  131.  glEnable(GL_BLEND); 
  132.  */
  133.  glEnable(GL_DEPTH_TEST);
  134.  
  135.  glShadeModel(GL_FLAT);
  136.  glColor3f(0.6,0.7,0.8);
  137. }
  138.  
  139. void buildFigure(void)
  140. {   GLint i, j;
  141.     float theta1, phi1, theta2, phi2, rings, sides;
  142.     float v0[03], v1[3], v2[3], v3[3];
  143.     float t0[03], t1[3], t2[3], t3[3];
  144.     float n0[3], n1[3], n2[3], n3[3];
  145.     float innerRadius=0.4;
  146.     float outerRadius=0.8;
  147.     float scalFac;
  148.  
  149.     rings = 8;
  150.     sides = 10;
  151.     scalFac=1/(outerRadius*2);
  152.  
  153.     glNewList(figure, GL_COMPILE);
  154.     for (i = 0; i < rings; i++) {
  155.     theta1 = (float)i * 2.0 * M_PI / rings;
  156.     theta2 = (float)(i + 1) * 2.0 * M_PI / rings;
  157.     for (j = 0; j < sides; j++) {
  158.         phi1 = (float)j * 2.0 * M_PI / sides;
  159.         phi2 = (float)(j + 1) * 2.0 * M_PI / sides;
  160.  
  161.         v0[0] = cos(theta1) * (outerRadius + innerRadius * cos(phi1));
  162.         v0[1] = -sin(theta1) * (outerRadius + innerRadius * cos(phi1));
  163.         v0[2] = innerRadius * sin(phi1);
  164.  
  165.         v1[0] = cos(theta2) * (outerRadius + innerRadius * cos(phi1));
  166.         v1[1] = -sin(theta2) * (outerRadius + innerRadius * cos(phi1));
  167.         v1[2] = innerRadius * sin(phi1);
  168.         v2[0] = cos(theta2) * (outerRadius + innerRadius * cos(phi2));
  169.         v2[1] = -sin(theta2) * (outerRadius + innerRadius * cos(phi2));
  170.         v2[2] = innerRadius * sin(phi2);
  171.  
  172.         v3[0] = cos(theta1) * (outerRadius + innerRadius * cos(phi2));
  173.         v3[1] = -sin(theta1) * (outerRadius + innerRadius * cos(phi2));
  174.         v3[2] = innerRadius * sin(phi2);
  175.  
  176.         n0[0] = cos(theta1) * (cos(phi1));
  177.         n0[1] = -sin(theta1) * (cos(phi1));
  178.         n0[2] = sin(phi1);
  179.  
  180.         n1[0] = cos(theta2) * (cos(phi1));
  181.         n1[1] = -sin(theta2) * (cos(phi1));
  182.         n1[2] = sin(phi1);
  183.  
  184.         n2[0] = cos(theta2) * (cos(phi2));
  185.         n2[1] = -sin(theta2) * (cos(phi2));
  186.         n2[2] = sin(phi2);
  187.  
  188.         n3[0] = cos(theta1) * (cos(phi2));
  189.         n3[1] = -sin(theta1) * (cos(phi2));
  190.         n3[2] = sin(phi2);
  191.  
  192.         t0[0] = v0[0]*scalFac + 0.5;
  193.         t0[1] = v0[1]*scalFac + 0.5;
  194.         t0[2] = v0[2]*scalFac + 0.5;
  195.  
  196.         t1[0] = v1[0]*scalFac + 0.5;
  197.         t1[1] = v1[1]*scalFac + 0.5;
  198.         t1[2] = v1[2]*scalFac + 0.5;
  199.  
  200.         t2[0] = v2[0]*scalFac + 0.5;
  201.         t2[1] = v2[1]*scalFac + 0.5;
  202.         t2[2] = v2[2]*scalFac + 0.5;
  203.  
  204.         t3[0] = v3[0]*scalFac + 0.5;
  205.         t3[1] = v3[1]*scalFac + 0.5;
  206.         t3[2] = v3[2]*scalFac + 0.5;
  207.  
  208.         glBegin(GL_POLYGON);
  209.         glNormal3fv(n3); glTexCoord3fv(t3); glVertex3fv(v3);
  210.         glNormal3fv(n2); glTexCoord3fv(t2); glVertex3fv(v2);
  211.         glNormal3fv(n1); glTexCoord3fv(t1); glVertex3fv(v1);
  212.         glNormal3fv(n0); glTexCoord3fv(t0); glVertex3fv(v0);
  213.         glEnd();
  214.     }
  215.     }
  216.     glEndList();
  217. }
  218.  
  219. void create3Dtexture()
  220. {
  221.  int i,j,k;
  222.  unsigned char *vp;
  223.  float vec[3];
  224.  int tmp;
  225.  
  226.  printf("creating 3d textures...\n");
  227.  voxels = (unsigned char  *) malloc((4*tex_width*tex_height*tex_depth));
  228.  vp=voxels;
  229.  for (i=0;i<tex_width;i++){
  230.     vec[0]=i;
  231.     for (j=0;j<tex_height;j++) {
  232.       vec[1]=j;
  233.        for (k=0;k<tex_depth;k++) {
  234.        vec[2]=k;
  235.        tmp=(sin(k*i*j+turbulence(vec,0.01,1))+1)*127.5; 
  236.        *vp++=0;
  237.        *vp++=0;
  238.        *vp++=tmp; 
  239.        *vp++=tmp+128; 
  240.        }
  241.      }
  242.  }
  243.  
  244.  printf("setting up 3d texture...\n");
  245.  glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
  246.  glTexParameteri(GL_TEXTURE_3D_EXT, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
  247.  glTexParameteri(GL_TEXTURE_3D_EXT, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
  248.  glTexParameteri(GL_TEXTURE_3D_EXT, GL_TEXTURE_WRAP_S,     GL_REPEAT);
  249.  glTexParameteri(GL_TEXTURE_3D_EXT, GL_TEXTURE_WRAP_T,     GL_REPEAT);
  250.  glTexParameteri(GL_TEXTURE_3D_EXT, GL_TEXTURE_WRAP_R_EXT, GL_REPEAT);
  251.  glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, (GLint)GL_DECAL);
  252.  
  253.  glTexImage3DEXT(GL_TEXTURE_3D_EXT, 0, GL_RGBA,
  254.             tex_width, tex_height, tex_depth,
  255.             0, GL_RGBA, GL_UNSIGNED_BYTE, voxels);
  256.  
  257.  printf("finished setting up 3d texture image...\n");
  258. }
  259.  
  260. int isExtSupported(char *ext)
  261. {
  262.     /* routine to find whether a specified OpenGL extension is supported */
  263.  
  264.     char *c;
  265.     int len;
  266.     char *allext = (char *)(glGetString(GL_EXTENSIONS));
  267.  
  268.     len = strlen(ext);
  269.     if (len <= 0) return 0;
  270.  
  271.     c = allext;
  272.     while (c) {
  273.     if (!strncmp(c,ext,len)) return 1;
  274.     c = strchr(c+1,'G');
  275.     }
  276.     return 0;
  277. }
  278.  
  279. void printHelp()
  280. {
  281.   printf("\nUsage: stex3d  <cmd line options>\n"); 
  282.   printf(" cmd line options:\n");
  283.   printf("      -help   print this help!\n");
  284.   printf("      -rgb     RGBA mode. (Default)\n");
  285.   printf("      -ci     Color index mode.\n");
  286.   printf("      -sb     Single buffer mode. (Default)\n");
  287.   printf("      -db     Double buffer mode. \n");
  288.   printf("      -dr     Direct render mode.\n");
  289.   printf("      -ir     Indirect render mode. (Default)\n");
  290.   printf("      -wxxx   Width of the texture (Default=64)\n");
  291.   printf("      -hxxx   Height of the texture (Default=64)\n");
  292.   printf("      -dxxx   Depth of the texture (Default=64)\n");
  293.   printf(" Keyboard Options:\n");
  294.   printf("       1      Object Texture coordinates (Default)\n");
  295.   printf("       2      Eye Texture coordinates \n");
  296.   printf("       x      rotate around x clockwise\n");
  297.   printf("       X      rotate around x counter clockwise\n");
  298.   printf("       y      rotate around y clockwise\n");
  299.   printf("       Y      rotate around y counter clockwise\n");
  300.   printf("       z      rotate around z clockwise\n");
  301.   printf("       Z      rotate around z counter clockwise\n");
  302.   printf("       t      enable 3-D texuring (Default)\n");
  303.   printf("       T      disable 3-D texuring\n");
  304.   printf("       s      smooth shading \n");
  305.   printf("       S      flat shading (Default)\n");
  306. }
  307.  
  308. void setDefaults()
  309. {
  310.  /* visualization defaults */
  311.   rgb = GL_TRUE;
  312.   doubleBuffer = GL_FALSE;
  313.   directRender = GL_TRUE;
  314.   angx=130;
  315.   angy=30;
  316.   angz=0; 
  317.  /* texture values */
  318.  tex_width=64;
  319.  tex_height=64;
  320.  tex_depth=64;
  321. }
  322.  
  323. GLenum parseCmdLine(int argc, char **argv)
  324. {
  325.   GLint i;
  326.  
  327.   setDefaults();
  328.  
  329.   for (i = 1; i < argc; i++) {
  330.       if (strcmp(argv[i], "-ci") == 0) {
  331.       rgb = GL_FALSE;
  332.       } else if (strcmp(argv[i], "-rgb") == 0) {
  333.       rgb = GL_TRUE;
  334.       } else if (strcmp(argv[i], "-sb") == 0) {
  335.       doubleBuffer = GL_FALSE;
  336.       } else if (strcmp(argv[i], "-db") == 0) {
  337.       doubleBuffer = GL_TRUE;
  338.       } else if (strcmp(argv[i], "-dr") == 0) {
  339.       directRender = GL_TRUE;
  340.       } else if (strcmp(argv[i], "-ir") == 0) {
  341.       directRender = GL_FALSE;
  342.       } else if (strstr(argv[i], "-w") == 0) {
  343.       tex_width=atoi((argv[i])+2);
  344.       } else if (strstr(argv[i], "-h") == 0) {
  345.       tex_height=atoi((argv[i])+2);
  346.       } else if (strstr(argv[i], "-d") == 0) {
  347.       tex_depth=atoi((argv[i])+2);
  348.       } else if (strcmp(argv[i], "-help") == 0) {
  349.       printHelp();
  350.       return GL_FALSE;
  351.       } else {
  352.       printf("%s (Bad option).\n", argv[i]);
  353.       printHelp();
  354.       return GL_FALSE;
  355.       }
  356.   }
  357.  if(tex_width==0 || tex_height==0 || tex_depth==0) {
  358.    printf("%s (Bad option).\n", "size parameters can't be 0");
  359.    printHelp();
  360.    return GL_FALSE;
  361.  }
  362.   return GL_TRUE;
  363. }
  364.  
  365. void drawScene()
  366. {
  367.  /* clear background, z buffer etc */
  368.  glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
  369.  glPushMatrix();
  370.  glRotatef(angx,1.0,0.0,0.0);
  371.  glRotatef(angy,0.0,1.0,0.0);
  372.  glRotatef(angz,0.0,0.0,1.0);
  373.  
  374.  glCallList(figure);     
  375.  glPopMatrix();
  376.  glFlush();
  377.  if(doubleBuffer)
  378.     glutSwapBuffers();
  379.  ;
  380. }
  381.  
  382. void resize(int w, int h)
  383. { 
  384.  glViewport(0, 0, (GLint)w, (GLint)h);
  385.  glMatrixMode(GL_PROJECTION);
  386.  glLoadIdentity();
  387.  glOrtho(-2,2,-2,2,-5,10);
  388.  glMatrixMode(GL_MODELVIEW);
  389.  glLoadIdentity();
  390.  glTranslatef(0,0,-5);
  391. }
  392.  
  393. void cleanEverything(void)
  394. {
  395. /*  free(voxels); */
  396. }
  397.  
  398.  
  399. void KeyHandler( unsigned char key, int x, int y )
  400. {
  401.    switch(key) {
  402.       case 27:
  403.       case 'q':
  404.       case 'Q': /* quit game. */
  405.      cleanEverything();
  406.      exit(0);
  407.      break;
  408.       case 'x':
  409.      angx+=10;
  410.      break;
  411.       case 'X': 
  412.      angx-=10; 
  413.      break;
  414.       case 'y':
  415.      angy+=10;
  416.      break;
  417.       case 'Y': 
  418.      angy-=10; 
  419.      break;
  420.       case 'z':
  421.      angz+=10;
  422.      break;
  423.       case 'Z': 
  424.      angz-=10; 
  425.      break;
  426.       case 't':
  427.      glEnable(GL_TEXTURE_3D_EXT); 
  428.      break;
  429.       case 'T':
  430.      glDisable(GL_TEXTURE_3D_EXT);
  431.      break;
  432.       case 's':
  433.      glShadeModel(GL_SMOOTH);
  434.      break;
  435.       case 'S':
  436.      glShadeModel(GL_FLAT);
  437.      break;
  438.       case '1':
  439.      glDisable(GL_TEXTURE_GEN_S);
  440.      glDisable(GL_TEXTURE_GEN_T);
  441.      glDisable(GL_TEXTURE_GEN_R);
  442.      break;
  443.       case '2':
  444.      glEnable(GL_TEXTURE_GEN_S);
  445.      glEnable(GL_TEXTURE_GEN_T);
  446.      glEnable(GL_TEXTURE_GEN_R);
  447.      break;
  448.       default:
  449.      break;
  450.    }
  451.    glutPostRedisplay();
  452. }
  453.  
  454. /*--------------------------------------------------------------------
  455.  noise function over R3 - implemented by a pseudorandom tricubic spline 
  456.           EXCERPTED FROM SIGGRAPH 92, COURSE 23
  457.             PROCEDURAL MODELING
  458.                  Ken Perlin
  459.                New York University
  460. ----------------------------------------------------------------------*/
  461.  
  462.  
  463. #define DOT(a,b) (a[0] * b[0] + a[1] * b[1] + a[2] * b[2])
  464. #define B 256
  465. static int p[B + B + 2];
  466. static float g[B + B + 2][3];
  467. #define setup(i,b0,b1,r0,r1) \
  468.     t = vec[i] + 10000.; \
  469.     b0 = ((int)t) & (B-1); \
  470.     b1 = (b0+1) & (B-1); \
  471.     r0 = t - (int)t; \
  472.     r1 = r0 - 1.;
  473.  
  474. float noise3(float vec[3])
  475. {
  476.     int bx0, bx1, by0, by1, bz0, bz1, b00, b10, b01, b11;
  477.     float rx0, rx1, ry0, ry1, rz0, rz1, *q, sx, sy, sz, a, b, c, d, t, u, v;
  478.     register int i, j;
  479.  
  480.     setup(0, bx0,bx1, rx0,rx1);
  481.     setup(1, by0,by1, ry0,ry1);
  482.     setup(2, bz0,bz1, rz0,rz1);
  483.  
  484.     i = p[ bx0 ];
  485.     j = p[ bx1 ];
  486.  
  487.     b00 = p[ i + by0 ];
  488.     b10 = p[ j + by0 ];
  489.     b01 = p[ i + by1 ];
  490.     b11 = p[ j + by1 ];
  491.  
  492. #define at(rx,ry,rz) ( rx * q[0] + ry * q[1] + rz * q[2] )
  493. #define surve(t) ( t * t * (3. - 2. * t) )
  494. #define lerp(t, a, b) ( a + t * (b - a) )
  495.  
  496.     sx = surve(rx0);
  497.     sy = surve(ry0);
  498.     sz = surve(rz0);
  499.  
  500.     q = g[ b00 + bz0 ] ; u = at(rx0,ry0,rz0);
  501.     q = g[ b10 + bz0 ] ; v = at(rx1,ry0,rz0);
  502.     a = lerp(sx, u, v);
  503.  
  504.     q = g[ b01 + bz0 ] ; u = at(rx0,ry1,rz0);
  505.     q = g[ b11 + bz0 ] ; v = at(rx1,ry1,rz0);
  506.     b = lerp(sx, u, v);
  507.  
  508.     c = lerp(sy, a, b);          /* interpolate in y at lo x */
  509.  
  510.     q = g[ b00 + bz1 ] ; u = at(rx0,ry0,rz1);
  511.     q = g[ b10 + bz1 ] ; v = at(rx1,ry0,rz1);
  512.     a = lerp(sx, u, v);
  513.  
  514.     q = g[ b01 + bz1 ] ; u = at(rx0,ry1,rz1);
  515.     q = g[ b11 + bz1 ] ; v = at(rx1,ry1,rz1);
  516.     b = lerp(sx, u, v);
  517.  
  518.     d = lerp(sy, a, b);          /* interpolate in y at hi x */
  519.  
  520.     return 1.5 * lerp(sz, c, d); /* interpolate in z */
  521. }
  522.  
  523. void initNoise()
  524. {
  525.     /*long random();*/
  526.     int i, j, k;
  527.     float v[3], s;
  528.  
  529. /* Create an array of random gradient vectors uniformly on the unit sphere */
  530.     /*srandom(1);*/
  531.     srand(1);
  532.     for (i = 0 ; i < B ; i++) {
  533.         do {                            /* Choose uniformly in a cube */                        for (j=0 ; j<3 ; j++)
  534.                 v[j] = (float)((rand() % (B + B)) - B) / B;
  535.             s = DOT(v,v);
  536.         } while (s > 1.0);              /* If not in sphere try again */                s = sqrt(s);
  537.         for (j = 0 ; j < 3 ; j++)       /* Else normalize */
  538.             g[i][j] = v[j] / s;
  539.     }
  540.  
  541. /* Create a pseudorandom permutation of [1..B] */
  542.     for (i = 0 ; i < B ; i++)
  543.         p[i] = i;
  544.     for (i = B ; i > 0 ; i -= 2) {
  545.         k = p[i];
  546.         p[i] = p[j = rand() % B];
  547.         p[j] = k;
  548.     }
  549.  
  550. /* Extend g and p arrays to allow for faster indexing */
  551.     for (i = 0 ; i < B + 2 ; i++) {
  552.         p[B + i] = p[i];
  553.         for (j = 0 ; j < 3 ; j++)
  554.             g[B + i][j] = g[i][j];
  555.     }
  556. }
  557.  
  558. float turbulence(float point[3], float lofreq, float hifreq)
  559. {
  560.     float freq, t, p[3];
  561.  
  562.     p[0] = point[0] + 123.456;
  563.     p[1] = point[1];
  564.     p[2] = point[2];
  565.  
  566.     t = 0;
  567.     for (freq = lofreq ; freq < hifreq ; freq *= 2.) {
  568.         t += fabs(noise3(p)) / freq;
  569.         p[0] *= 2.;
  570.         p[1] *= 2.;
  571.         p[2] *= 2.;
  572.     }
  573.     return t - 0.3; /* readjust to make mean value = 0.0 */
  574. }
  575.  
  576.